home *** CD-ROM | disk | FTP | other *** search
/ IBM InfoROM for OS/2 Beta 1995 January / IBM InfoROM for OS2 Beta 1-1995.ISO / testcert / storage / function / cdrom / global.gra < prev    next >
Encoding:
Text File  |  1994-10-10  |  18.3 KB  |  427 lines

  1. ******************************************************************************
  2. **                       GLOBAL.GRA DESCRIPTION FILE                        **
  3. ******************************************************************************
  4. **                          GLOBAL FUNCTION CALLS                           **
  5. ******************************************************************************
  6. SET                            $DLL=GLOBAL  \
  7.                                $FUNC=_set 
  8. **
  9. ** THIS FUNCTION SETS A VARIABLE EQUAL TO THE PASSED VALUE. THIS FUNCTION
  10. ** NEEDS BOTH THE VARIABLE AND VALUE.
  11. ** 
  12. **   NEEDED PARAMETERS:          VARIABLE
  13. **                               VALUE 
  14. **
  15. **   EXAMPLE:                    SET DEVICENAME=E:
  16. ** 
  17. **   RETURNS:                    SET VARIABLE 
  18. **
  19. ******************************************************************************
  20. LOG                            $DLL=GLOBAL  \
  21.                                $FUNC=_log
  22. **                                      
  23. ** THIS FUNCTION WILL PLACE A TIME STAMP IN THE OUPUT FILE FOR THE SCRIPT
  24. ** FILE WHEN IT IS CALLED. IT CAN EITHER JUST LOG THE TIME OR IT CAN ALSO
  25. ** LOG THE TIME AND A MESSAGE IN THE SAME CALL.
  26. ** 
  27. **   NEEDED PARAMETERS:          MESSAGE TO BE DISPLAYED (OPTIONAL)
  28. **
  29. **   EXAMPLE:                    LOG                    - TIME STAMP
  30. **                               LOG $PROMPT="message"  - TIME STAMP & MESSAGE
  31. **
  32. **   RETURNS:                    NOTHING 
  33. **
  34. ******************************************************************************
  35. RESPONSE                       $DLL=GLOBAL  \
  36.                                $FUNC=_input
  37. **                                      
  38. ** THIS FUNCTION WILL DISPLAY A MESSAGE AND THEN WAIT FOR A RESPONSE TO THE
  39. ** MESSAGE. THE AMOUNT OF TIME THAT THE THREAD WILL WAIT FOR THE RESPONSE
  40. ** CAN BE SET WITH THE PAUSE COMMAND. IF A VALUE OF -1 IS PASSED, THE THREAD
  41. ** WILL WAIT INDEFINITELY UNTIL THE ENTER KEY IS PRESSED. 
  42. ** 
  43. **   NEEDED PARAMETERS:          MESSAGE TO BE DISPLAYED
  44. **                               TIME TO WAIT FOR RESPONSE - IN SECONDS 
  45. **
  46. **   EXAMPLE:                    RESPONSE $PROMPT="message" $PAUSE=seconds
  47. ** 
  48. **   RETURNS:                    NOTHING 
  49. **
  50. ******************************************************************************
  51. DUMP                           $DLL=GLOBAL  \
  52.                    $BUFFER=STRING  \    
  53.                                $FUNC=_dump
  54. **                                      
  55. ** THIS FUNCTION WILL PLACE THE CONTENTS OF A BUFFER IN THE LOG FILE.
  56. ** 
  57. **   NEEDED PARAMETERS:          BUFFER OF DATA 
  58. **
  59. **   EXAMPLE:                    SET BUFFER=ALPHA    - SET BUFFER
  60. **                               CDROM_READFILE      - FILL BUFFER
  61. **                               DUMP $BUFFER=ALPHA  - DUMP BUFFER
  62. **                                
  63. **   RETURNS:                    NOTHING 
  64. **
  65. ******************************************************************************
  66. PAUSE                          $DLL=GLOBAL  \
  67.                                $PAUSE=NUM  \ 
  68.                                $FUNC=_pause 
  69. **                                      
  70. ** THIS FUNCTION WILL PAUSE THE THREAD FOR A CERTAIN AMOUNT OF TIME.
  71. ** THE AMOUNT OF TIME THAT THE THREAD WILL WAIT NEEDS TO BE PASSED TO THE
  72. ** FUNCTION. 
  73. ** 
  74. **   NEEDED PARAMETERS:          TIME TO WAIT - IN SECONDS
  75. **
  76. **   EXAMPLE:                    PAUSE $PAUSE=seconds
  77. ** 
  78. **   RETURNS:                    NOTHING 
  79. **
  80. ******************************************************************************
  81. OUT                           $DLL=GLOBAL  \
  82.                    $KWD=STRING  \    
  83.                                $FUNC=_out 
  84. **                                      
  85. ** THIS FUNCTION WILL OUTPUT THE VALUE OF A KEYWORD FROM THE KEYWORD LIST. 
  86. ** 
  87. **   NEEDED PARAMETERS:          KEYWORD   
  88. **
  89. **   EXAMPLE:                    CD OUT $KWD=DEVICENAME
  90. **                                    
  91. **   RETURNS:                    VALUE OF KEYWORD
  92. **
  93. ******************************************************************************
  94. CLEAR                           $DLL=GLOBAL  \
  95.                    $BUFFER=STRING  \    
  96.                                $FUNC=_clear 
  97. **                                      
  98. ** THIS FUNCTION WILL CLEAR THE CONTENTS OF A BUFFER BY SETTING ALL OF THE 
  99. ** BITS TO 0'S.  
  100. ** 
  101. **   NEEDED PARAMETERS:          BUFFER
  102. **
  103. **   EXAMPLE:                    SET BUFFER=BETA       - SET BUFFER
  104. **                               CDROM_READFILE        - FILL BUFFER
  105. **                               CLEAR $BUFFER=BETA    - CLEAR BUFFER 
  106. **                                    
  107. **   RETURNS:                    NOTHING 
  108. **
  109. ******************************************************************************
  110. COMPARE                           $DLL=GLOBAL   \
  111.                    BUFFER1=STRING  \
  112.                    BUFFER2=STRING  \    
  113.                                $FUNC=_compare 
  114. **
  115. ** THIS FUNCTION WILL COMPARE THE CONTENTS OF 2 BUFFERS. IT WILL EITHER RETURN
  116. ** A BUFFER COMPARE SUCCESS OR A BUFFER COMPARE FAILURE.
  117. ** 
  118. **   NEEDED PARAMETERS:          BUFFER1
  119. **                               BUFFER2 
  120. **
  121. **   EXAMPLE:                    SET BUFFER=ALPHA       
  122. **                               cd set SECTORSTART=20
  123. **                               cd set SECTORCOUNT=400
  124. **                               cd set ADDRESSMODE=LOGICALBLOCK
  125. **                               cd CDROM_OPEN
  126. **                               cd CDROM_READ2048
  127. **                               @loop 2
  128. **                               cd CDROM_READ2048 BUFFER=BETA 
  129. **                               cd COMPARE BUFFER1=ALPHA BUFFER2=BETA
  130. **                               cd CLEAR $BUFFER=BETA
  131. **                               @endloop
  132. **                                    
  133. **   RETURNS:                    RESULTS OF BUFFER COMPARE
  134. **
  135. ******************************************************************************
  136. DECREMENT                      $DLL=GLOBAL  \
  137.                                $COUNT=NUM  \ 
  138.                                $FUNC=_decrement  
  139. **                                      
  140. ** THIS FUNCTION WILL DECREMENT THE LOOP COUNTER VARIABLE BY 1 EACH TIME IT IS 
  141. ** INCOUNTERED. 
  142. ** 
  143. **   NEEDED PARAMETERS:          LOOP COUNTER
  144. **
  145. **   EXAMPLE:                    SET BUFFER=BETA       - SET BUFFER
  146. **                               CDROM_QUERYAUDIODISKINFO
  147. **                               set $COUNT=$(HIGHTRACK)
  148. **                               response $PROMPT="QUERYING AUDIO TRACK INFO" 
  149. **                               @loop [alias name, hightrack]
  150. **                               set track=$($COUNT)
  151. **                               CDROM_QUERYAUDIOTRACKINFO
  152. **                               DECREMENT   
  153. **                               @endloop
  154. **                                    
  155. **   RETURNS:                    LOOPCOUNTER 
  156. **
  157. ******************************************************************************
  158. INCREMENT                      $DLL=GLOBAL  \
  159.                                $COUNT=NUM  \ 
  160.                                $FUNC=_increment 
  161. **                                      
  162. ** THIS FUNCTION WILL INCREMENT THE LOOP COUNTER VARIABLE BY 1 EACH TIME IT IS 
  163. ** INCOUNTERED. 
  164. ** 
  165. **   NEEDED PARAMETERS:          LOOP COUNTER
  166. **
  167. **   EXAMPLE:                    SET BUFFER=BETA       - SET BUFFER
  168. **                               CDROM_QUERYAUDIODISKINFO
  169. **                               set $COUNT=$(LOWTRACK)
  170. **                               response $PROMPT="QUERYING AUDIO TRACK INFO" 
  171. **                               @loop [alias name, hightrack]
  172. **                               set track=$($COUNT)
  173. **                               CDROM_QUERYAUDIOTRACKINFO
  174. **                               INCREMENT   
  175. **                               @endloop
  176. **                                    
  177. **   RETURNS:                    LOOPCOUNTER 
  178. **
  179. ******************************************************************************
  180. LABEL                           $DLL=GLOBAL  \
  181.                    $LABEL=STRING  \
  182.                                $FUNC=_label
  183. **                                      
  184. ** THIS FUNCTION WILL ASSOCIATE A NAME(LABEL) WITH A LINE. AFTER A
  185. ** LINE HAS BEEN LABELED, GOTO CAN BE USED TO JUMP TO IT.
  186. ** 
  187. **   NEEDED PARAMETERS:          LABEL NAME
  188. **
  189. **   EXAMPLE:                    CD LABEL $LABEL="test" - NAMES LINE
  190. **                               CD GOTO $LABEL="test"  - GOTOS LINE
  191. **                                    
  192. **   RETURNS:                    NOTHING 
  193. **
  194. ******************************************************************************
  195. PROC                              $DLL=GLOBAL  \
  196.                    $LABEL=STRING  \
  197.                    $LINES=NUM   \    
  198.                                $FUNC=_proc
  199. **                                      
  200. ** THIS FUNCTION WILL CREATE A PROCEDURE AND DEFINE ALL OF THE STATEMENTS
  201. ** THAT ARE IN THAT PROCEDURE.  WHEN YOU DEFINE THE PROCEDURE, YOU MUST 
  202. ** ALSO LIST THE LABEL NAME AND THE NUMBER OF LINES IN THE PROCEDURE. THE
  203. ** PROCEDURE LINE SHOULD NOT BE INCLUDED IN THE LINE COUNT. THE RETURN LINE 
  204. ** SHOULD BE INCLUDED IN THE LINE COUNT.
  205. ** 
  206. **   NEEDED PARAMETERS:          LABEL NAME
  207. **                               # OF LINES
  208. **                               PROCEDURE FUNCTIONS
  209. **
  210. **   EXAMPLE:                    PROC $LABEL="test" $LINES=6
  211. **                                 CDROM_OPEN
  212. **                                 CDROM_LOCKDOOR
  213. **                                 CDROM_QUERYCHANNELINFO
  214. **                                 CDROM_UNLOCKDOOR
  215. **                                 CDROM_CLOSE
  216. **                               RETURN                                      
  217. **                                    
  218. **   RETURNS:                    NOTHING 
  219. **
  220. ******************************************************************************
  221. GOTO                           $DLL=GLOBAL  \
  222.                    $LABEL=STRING  \
  223.                                $FUNC=_jump
  224. **                                      
  225. ** THIS FUNCTION WILL GOTO A PARTICULAR LABELED LINE WHEN THIS LINE IS 
  226. ** INCOUNTERED IN A SCRIPT FILE. 
  227. ** 
  228. **   NEEDED PARAMETERS:          LABEL NAME
  229. **
  230. **   EXAMPLE:                    GOTO $LABEL="test"  
  231. **                                    
  232. **   RETURNS:                    NOTHING 
  233. **
  234. ******************************************************************************
  235. CALL                           $DLL=GLOBAL  \
  236.                    $LABEL=STRING  \
  237.                                $FUNC=_call
  238. **                                      
  239. ** THIS FUNCTION WILL CALL A PARTICULAR PROCEDURE WHEN THIS LINE IS 
  240. ** INCOUNTERED IN A SCRIPT FILE. WHEN THE PROCEDURE HAS FINISHED, (AND A RETURN
  241. ** STATEMENT IS ENCOUNTERED) IT WILL JUMP BACK TO THE NEXT LINE IN THE 
  242. ** SCRIPT FILE.
  243. ** 
  244. **   NEEDED PARAMETERS:          LABEL NAME
  245. **
  246. **   EXAMPLE:                    CALL $LABEL="test"  
  247. **                                    
  248. **   RETURNS:                    NOTHING 
  249. **
  250. ******************************************************************************
  251. RETURN                           $DLL=GLOBAL  \
  252.                                $FUNC=_ret
  253. **                                      
  254. ** THIS FUNCTION SIGNIFIES THE END OF A PROCEDURE. WHEN THIS LINE IS 
  255. ** INCOUNTERED IN A PROCEDURE, THE FLOW OF CONTROL WITH RETURN TO THE LINE
  256. ** WHERE THE PROCEDURE WAS CALLED FROM.
  257. ** 
  258. **   NEEDED PARAMETERS:          NOTHING
  259. **
  260. **   EXAMPLE:                    PROC $LABEL="test" $LINES=6
  261. **                                 CDROM_OPEN
  262. **                                 CDROM_LOCKDOOR
  263. **                                 CDROM_QUERYCHANNELINFO
  264. **                                 CDROM_UNLOCKDOOR
  265. **                                 CDROM_CLOSE
  266. **                               RETURN                                      
  267. **                  
  268. **   RETURNS:                    NOTHING 
  269. **
  270. ******************************************************************************
  271. ADD                           $DLL=GLOBAL  \
  272.                    $OP1=STRING \
  273.                    $OP2=STRING \    
  274.                    $RESULT=STRING  \    
  275.                                $FUNC=_add 
  276. **                                      
  277. ** THIS FUNCTION WILL ADD 2 VARIABLES AND PLACE THE SUM IN A RESULT STRING.
  278. ** 
  279. **   NEEDED PARAMETERS:          2 VARIABLES THAT WILL BE ADDED
  280. **                               RESULT VARIABLE
  281. **
  282. **   EXAMPLE:                    SET VAL1=2
  283. **                               SET VAL2=10
  284. **                               ADD $OP1=$(VAL1) $OP2=$(VAL2) $RESULT=SUM
  285. **                                    
  286. **   RETURNS:                    RESULT VARIABLE 
  287. **
  288. ******************************************************************************
  289. SUB                           $DLL=GLOBAL  \
  290.                    $OP1=STRING  \
  291.                    $OP2=STRING  \
  292.                    $RESULT=STRING  \    
  293.                                $FUNC=_sub
  294. **                                      
  295. ** THIS FUNCTION WILL SUBTRACT 1 VARIABLE FROM ANOTHER VARIABLE AND PLACE THE 
  296. ** DIFFERENCE IN A RESULT STRING. 
  297. ** 
  298. **   NEEDED PARAMETERS:          2 VARIABLES THAT WILL BE ADDED
  299. **                               RESULT VARIABLE
  300. **
  301. **   EXAMPLE:                    SET VAL1=10
  302. **                               SET VAL2=3
  303. **                               SUB $OP1=$(VAL1) $OP2=$(VAL2) $RESULT=SUM   
  304. **                                    
  305. **   RETURNS:                    RESULT VARIABLE 
  306. **
  307. ******************************************************************************
  308. IF                           $DLL=GLOBAL  \
  309.                                $FUNC=_IF
  310. **                                      
  311. ** THIS FUNCTION WILL SKIP THE NEXT LINE IF THE $COND KEYWORD IS UNDEFINED OR ZERO.
  312. ** 
  313. **   NEEDED PARAMETERS:          CONDITION VARIABLE
  314. **
  315. **   EXAMPLE:                    SET SUPPORTED=1
  316. **                               IF $COND=$(SUPPORTED)
  317. **                                  response $PROMPT="SUPPORTED" $PAUSE=0
  318. **                               CDROM_LOCKDOOR                                  
  319. **                                    
  320. **   RETURNS:                    CONDITION VARIABLE 
  321. **
  322. ******************************************************************************
  323. DOFOR                           $DLL=GLOBAL   \
  324.                                $FUNC=_doloop
  325. **                                      
  326. ** THIS FUNCTION WILL LOOP UNTIL THE RESULT VARIABLE $COND IS EQUAL TO ZERO.
  327. ** THIS FUNCTION WILL AUTOMATICALLY INCREMENT $I BY 1 EACH TIME THROUGH THE
  328. ** LOOP. THIS SIGNIFIES THE START OF THE LOOP.  THE LOOP WILL BE EXECUTED AT
  329. ** LEAST ONCE.
  330. ** 
  331. **   NEEDED PARAMETERS:          EXPRESSION TO BE EVALUATED
  332. **
  333. **   EXAMPLE:                    SET $I=0
  334. **                               DOFOR 
  335. **                                 SUB $OP1=10  $OP2=$($I) 
  336. **                                 @PAUSE 5
  337. **                               ENDFOR
  338. **     
  339. **   RETURNS:                    none
  340. **
  341. ******************************************************************************
  342. ENDFOR                         $DLL=GLOBAL   \
  343.                                $FUNC=_endfor
  344. **                                      
  345. ** THIS FUNCTION WILL LOOP UNTIL THE RESULT VARIABLE $COND IS EQUAL TO ZERO.
  346. ** THIS FUNCTION WILL AUTOMATICALLY INCREMENT $I BY 1 EACH TIME THROUGH THE
  347. ** LOOP. THIS SIGNIFIES THE END OF THE LOOP.  THE LOOP WILL BE EXECUTED AT
  348. ** LEAST ONCE.
  349. ** 
  350. **   NEEDED PARAMETERS:          EXPRESSION TO BE EVALUATED
  351. **
  352. **   EXAMPLE:                    SET $I=0
  353. **                               SET $RESULT=$COND
  354. **                               DOFOR 
  355. **                                 SUB $OP1=10  $OP2=$($I) 
  356. **                                 @PAUSE 5
  357. **                               ENDFOR
  358. **     
  359. **   RETURNS:                    $COND
  360. **
  361. ******************************************************************************
  362. DOWHILE                           $DLL=GLOBAL   \
  363.                                $RESULT=STRING  \
  364.                                $FUNC=_doloop
  365. **                                     
  366. ** THIS FUNCTION WILL LOOP UNTIL THE RESULT VARIABLE IS EQUAL TO ZERO.
  367. ** THIS FUNCTION DOES NOT AUTOMATICALLY INCREMENT $I BY 1 EACH TIME THROUGH THE
  368. ** LOOP. THIS SIGNIFIES THE START OF THE LOOP. THE LOOP WILL BE EXECUTED AT
  369. ** LEAST ONCE.
  370. ** 
  371. **   NEEDED PARAMETERS:          EXPRESSION TO BE EVALUATED
  372. **                               RESULT VARIABLE
  373. **
  374. **   EXAMPLE:                    DOWHILE
  375. **                   RESPONSE $PROMPT="ENTER 0 TO CONTINUE" \
  376. **                    $RESPONSE=$COND $PAUSE=-1
  377. **                 ENDWHILE
  378. **     
  379. **   RETURNS:                    RESULT VARIABLE 
  380. **
  381. ******************************************************************************
  382. ENDWHILE                       $DLL=GLOBAL   \
  383.                                $RESULT=STRING  \
  384.                                $FUNC=_endwhile
  385. **                                     
  386. ** THIS FUNCTION WILL LOOP UNTIL THE RESULT VARIABLE IS EQUAL TO ZERO.
  387. ** THIS FUNCTION DOES NOT AUTOMATICALLY INCREMENT I BY 1 EACH TIME THROUGH THE
  388. ** LOOP. THIS SIGNIFIES THE END OF THE LOOP.  THE LOOP WILL BE EXECUTED AT
  389. ** LEAST ONCE.
  390. ** 
  391. **   NEEDED PARAMETERS:          EXPRESSION TO BE EVALUATED
  392. **                               RESULT VARIABLE
  393. **
  394. **   EXAMPLE:                    DOWHILE
  395. **                   RESPONSE $PROMPT="ENTER 0 TO CONTINUE" \
  396. **                    $RESPONSE=$COND $PAUSE=-1
  397. **                 ENDWHILE
  398. **     
  399. **   RETURNS:                    RESULT VARIABLE 
  400. **
  401. ******************************************************************************
  402.  
  403. MAKEIMPORT                     $DLL=GLOBAL \
  404.                                $FUNC=_filedump \
  405.                                $FILENAME=STRING \
  406.                                $COMMAND=STRING \
  407.                                $ALIAS=STRING
  408. **                                     
  409. ** THIS FUNCTION CREATES A FILE OF $FILENAME, PUTS THE STRING "$ALIAS $COMMAND"
  410. ** IN THE FILE, ALSO, NOT REQUIRED, BUT CAN BE SPECIFIED ARE $KWD AND $VALUE.
  411. ** 
  412. **   NEEDED PARAMETERS:          $FILENAME - FILE TO CTREATE
  413. **                               $COMMAND  - COMMAND
  414. **                               $ALIAS    - ALIAS
  415. **
  416. **   EXAMPLE:                    ALIAS MAKEIMPORT \
  417. **                       $FILENAME=IMPORT.TXT \
  418. **                                     $ALIAS=ALIAS \
  419. **                                     $COMMAND=COMMAND
  420. **                 
  421. **     
  422. **   RETURNS:                    NONE.
  423. **
  424. ******************************************************************************
  425.  
  426.  
  427.